home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / castools.zip / FAXCOPYE.C < prev    next >
Text File  |  1990-01-05  |  8KB  |  219 lines
  1.  
  2.  
  3. /*
  4.    FAXCOPYE.C  A high-level CAS Toolkit function.
  5.  
  6.    This function allocates an Event Control structure, fills its fields with
  7.    those of the source structure, and returns a pointer to the copy.  All
  8.    the memory used by the copy is separate from that used by the source.
  9.  
  10.    INPUT:  A complete Event Control Structure as source for copy, and possibly
  11.             one for the copy as well.
  12.  
  13.    OUTPUT: A pointer to the copy of the source structure.
  14. */
  15.  
  16. #include <stdlib.h>
  17. #include <stdio.h>
  18. #include <malloc.h>
  19. #include <string.h>
  20. #include <cas.h>
  21. #include <fax.h>
  22.  
  23. ECS * pascal FAXCopyECS(ECS *SourceECS, ECS *CopyECS)
  24. {
  25.   ECS *Copy;
  26.   size_t CoverLength = SourceECS->EventControlFile.FTROffset - 383;
  27.   int FileCount;
  28.   FTRLIST *CurrFTRL, *DestFTRL;
  29.  
  30.   FAXerrno = 0;             /* If it keeps it, all went well. */
  31.  
  32.   /* If caller provides Copy structure, check that it's all initialized */
  33.   if (CopyECS) {
  34.     if (CoverLength) {
  35.       if (!CopyECS->CoverPageText) {
  36.         FAXerrno = INVALIDPTR;
  37.         return(NULL);
  38.       }
  39.     }
  40.     for (FileCount = 0, CurrFTRL = CopyECS->FirstFTR;
  41.          FileCount < SourceECS->EventControlFile.FileCount;
  42.          FileCount++, CurrFTRL = CurrFTRL->next) {
  43.       if (!CurrFTRL) {
  44.         FAXerrno = INVALIDPTR;
  45.         return(NULL);
  46.       }
  47.     }
  48.     Copy = CopyECS;
  49.   }
  50.   else {
  51.     Copy = (ECS *)calloc(1, sizeof(ECS));
  52.     if (!Copy) {
  53.       FAXerrno = OUTOFMEMORY;
  54.       return(NULL);
  55.     }
  56.   }
  57.  
  58.   /*  Start with Event Control File fields */
  59.   Copy->EventControlFile.EventType = SourceECS->EventControlFile.EventType;
  60.   Copy->EventControlFile.TransferType = SourceECS->EventControlFile.TransferType;
  61.   Copy->EventControlFile.EventStatus = SourceECS->EventControlFile.EventStatus;
  62.   Copy->EventControlFile.EventTime = SourceECS->EventControlFile.EventTime;
  63.   Copy->EventControlFile.EventDate = SourceECS->EventControlFile.EventDate;
  64.   Copy->EventControlFile.FileCount = SourceECS->EventControlFile.FileCount;
  65.   Copy->EventControlFile.FTROffset = SourceECS->EventControlFile.FTROffset;
  66.   strncpy(Copy->EventControlFile.Phone,
  67.           SourceECS->EventControlFile.Phone,
  68.           PHONENUMLENGTH);
  69.   if (Copy->EventControlFile.Phone[PHONENUMLENGTH-1]) {
  70.     FAXerrno = STRINGTOOLONG;
  71.     Copy->EventControlFile.Phone[PHONENUMLENGTH-1] = '\0';
  72.   }
  73.   strncpy(Copy->EventControlFile.ApplicationTag,
  74.           SourceECS->EventControlFile.ApplicationTag,
  75.           APPTAGLENGTH);
  76.   if (Copy->EventControlFile.ApplicationTag[APPTAGLENGTH-1]) {
  77.     FAXerrno = STRINGTOOLONG;
  78.     Copy->EventControlFile.ApplicationTag[APPTAGLENGTH-1] = '\0';
  79.   }
  80.   Copy->EventControlFile.RESERVED1 = SourceECS->EventControlFile.RESERVED1;
  81.   Copy->EventControlFile.ConnectSeconds = SourceECS->EventControlFile.ConnectSeconds;
  82.   Copy->EventControlFile.ConnectMinutes = SourceECS->EventControlFile.ConnectMinutes;
  83.   Copy->EventControlFile.ConnectHours = SourceECS->EventControlFile.ConnectHours;
  84.   Copy->EventControlFile.TotalPages = SourceECS->EventControlFile.TotalPages;
  85.   Copy->EventControlFile.PagesSent = SourceECS->EventControlFile.PagesSent;
  86.   Copy->EventControlFile.FilesSent = SourceECS->EventControlFile.FilesSent;
  87.   Copy->EventControlFile.SendCover = SourceECS->EventControlFile.SendCover;
  88.   Copy->EventControlFile.ErrorCount = SourceECS->EventControlFile.ErrorCount;
  89.   memcpy(Copy->EventControlFile.RESERVED2,
  90.          SourceECS->EventControlFile.RESERVED2,
  91.          78);
  92.   strncpy(Copy->EventControlFile.RemoteCSID,
  93.           SourceECS->EventControlFile.RemoteCSID,
  94.           CSIDLENGTH);
  95.   if (Copy->EventControlFile.RemoteCSID[CSIDLENGTH-1]) {
  96.     FAXerrno = STRINGTOOLONG;
  97.     Copy->EventControlFile.RemoteCSID[CSIDLENGTH-1] = '\0';
  98.   }
  99.   strncpy(Copy->EventControlFile.DestinationName,
  100.           SourceECS->EventControlFile.DestinationName,
  101.           NAMELENGTH);
  102.   if (Copy->EventControlFile.DestinationName[NAMELENGTH-1]) {
  103.     FAXerrno = STRINGTOOLONG;
  104.     Copy->EventControlFile.DestinationName[NAMELENGTH-1] = '\0';
  105.   }
  106.   strncpy(Copy->EventControlFile.SenderName,
  107.           SourceECS->EventControlFile.SenderName,
  108.           NAMELENGTH);
  109.   if (Copy->EventControlFile.SenderName[NAMELENGTH-1]) {
  110.     FAXerrno = STRINGTOOLONG;
  111.     Copy->EventControlFile.SenderName[NAMELENGTH-1] = '\0';
  112.   }
  113.   strncpy(Copy->EventControlFile.LogoFilePath,
  114.           SourceECS->EventControlFile.LogoFilePath,
  115.           FULLFNAMELENGTH);
  116.   if (Copy->EventControlFile.LogoFilePath[FULLFNAMELENGTH-1]) {
  117.     FAXerrno = STRINGTOOLONG;
  118.     Copy->EventControlFile.LogoFilePath[FULLFNAMELENGTH-1] = '\0';
  119.   }
  120.  
  121.   /*  Now the coverpage text */
  122.   if (CoverLength) {
  123.     if (!CopyECS) {                                       /* we're allocating */
  124.       Copy->CoverPageText = (char *)calloc(CoverLength, sizeof(char));
  125.       if (!Copy->CoverPageText) {
  126.         FAXerrno = OUTOFMEMORY;
  127.         if (!CopyECS) {
  128.           freeup(Copy);
  129.         }
  130.         return(NULL);
  131.       }
  132.     }
  133.     strncpy(Copy->CoverPageText, SourceECS->CoverPageText, CoverLength);
  134.     if (SourceECS->CoverPageText[CoverLength-1]) {
  135.       FAXerrno = STRINGTOOLONG;
  136.       Copy->CoverPageText[CoverLength-1] = '\0';
  137.     }
  138.   }
  139.   else Copy->CoverPageText = NULL;
  140.  
  141.   /* Then the File Transfer Records list */
  142.   if (SourceECS->FirstFTR) {     /* There is at least one file */
  143.     if (!CopyECS) {
  144.       Copy->FirstFTR = (FTRLIST *)calloc(1, sizeof(FTRLIST));
  145.       if (!Copy->FirstFTR) {
  146.         FAXerrno = OUTOFMEMORY;
  147.         if (!CopyECS) {
  148.           freeup(Copy);
  149.         }
  150.         return(NULL);
  151.       }
  152.     }
  153.     CurrFTRL = SourceECS->FirstFTR;
  154.     DestFTRL = Copy->FirstFTR;
  155.     for (FileCount = 0;
  156.          FileCount < SourceECS->EventControlFile.FileCount;
  157.          FileCount++, CurrFTRL = CurrFTRL->next) {
  158.  
  159.       if (!CurrFTRL) {             /* Before FileCount says we're done, we */
  160.         FAXerrno = BADFILECOUNT;   /*    are out of pointers to new FTRs */
  161.         if (!CopyECS) {
  162.           freeup(Copy);
  163.         }
  164.         return(NULL);
  165.       }
  166.  
  167.       /* Except for first time through, advance dest FTRL, malloc'ing if nec. */
  168.       if (FileCount) {
  169.         if (!CopyECS) {
  170.           DestFTRL->next = (FTRLIST *)calloc(1, sizeof(FTRLIST));
  171.           if (!DestFTRL->next) {
  172.             FAXerrno = OUTOFMEMORY;
  173.             freeup(Copy);
  174.             return(NULL);
  175.           }
  176.         }
  177.         DestFTRL = DestFTRL->next;
  178.       }
  179.       DestFTRL->OneFTR.FileType          =  CurrFTRL->OneFTR.FileType;
  180.       DestFTRL->OneFTR.TextSize          =  CurrFTRL->OneFTR.TextSize;
  181.       DestFTRL->OneFTR.FileStatus        =  CurrFTRL->OneFTR.FileStatus;
  182.       DestFTRL->OneFTR.BytesSent         =  CurrFTRL->OneFTR.BytesSent;
  183.       DestFTRL->OneFTR.FileSize          =  CurrFTRL->OneFTR.FileSize;
  184.       DestFTRL->OneFTR.PagesSent         =  CurrFTRL->OneFTR.PagesSent;
  185.       DestFTRL->OneFTR.PageCount         =  CurrFTRL->OneFTR.PageCount;
  186.       strncpy(DestFTRL->OneFTR.FileName,
  187.               CurrFTRL->OneFTR.FileName,
  188.               FULLFNAMELENGTH);
  189.       if (DestFTRL->OneFTR.FileName[FULLFNAMELENGTH-1]) {
  190.         FAXerrno = STRINGTOOLONG;
  191.         DestFTRL->OneFTR.FileName[FULLFNAMELENGTH-1] = '\0';
  192.       }
  193.       DestFTRL->OneFTR.AddPageIncrements =  CurrFTRL->OneFTR.AddPageIncrements;
  194.       DestFTRL->OneFTR.PageLength        =  CurrFTRL->OneFTR.PageLength;
  195.       memcpy(DestFTRL->OneFTR.RESERVED,     CurrFTRL->OneFTR.RESERVED, 31);
  196.       if (!CopyECS) {
  197.         DestFTRL->next = NULL;
  198.       }
  199.     }                   /* done reading FileCount FTR's */
  200.  
  201.     /* If, after FileCount FTR's, there are still more in source, warning */
  202.     if (CurrFTRL) {
  203.       FAXerrno = MOREFTRSTHANFC;
  204.     }
  205.   }
  206.   else {
  207.     if (SourceECS->EventControlFile.FileCount) {
  208.       FAXerrno = BADFILECOUNT;
  209.       if (!CopyECS) {
  210.         freeup(Copy);
  211.       }
  212.       return(NULL);
  213.     }
  214.   }
  215.  
  216.   /* Just to be exact, if the source points to another, let the dest also */
  217.   return(Copy);
  218. }
  219.